/**
 * 用户认证相关路由
 */
const express = require('express');
const router = express.Router();
const userService = require('../services/userService');
const logger = require('../utils/logger');
const path = require('path');

module.exports = function(pool) {
  /**
   * 微信登录
   */
  router.post('/wechat-login', async (req, res) => {
    const { code, userInfo } = req.body;
    
    if (!code) {
      return res.status(400).json({
        success: false,
        message: '缺少登录code'
      });
    }
    
    try {
      // 获取微信openID
      const wxSession = await userService.getOpenIdByCode(code);
      
      // 保存用户信息
      const user = await userService.saveUserInfo(pool, wxSession.openid, userInfo || {});
      
      // 返回登录信息
      return res.json({
        success: true,
        data: {
          userId: user.id,
          openId: wxSession.openid,
          nickName: user.nick_name,
          avatarUrl: user.avatar_url
        }
      });
    } catch (err) {
      logger.error('微信登录失败', {
        error: err.message,
        stack: err.stack
      });
      
      return res.status(500).json({
        success: false,
        message: '登录处理失败',
        error: err.message
      });
    }
  });
  
  /**
   * 保存诊断历史记录
   */
  router.post('/save-diagnosis', async (req, res) => {
    const { userId, diagnosisRecord } = req.body;
    
    if (!userId || !diagnosisRecord) {
      return res.status(400).json({
        success: false,
        message: '缺少必要参数'
      });
    }
    
    try {
      // 处理图片保存，如果是本地临时路径
      let imageUrl = diagnosisRecord.imageUrl || '';
      
      // 如果传入的图片是Base64编码，需要保存为文件
      if (imageUrl.startsWith('data:image')) {
        // 此处需要实现图片保存逻辑
        logger.info('收到Base64图片数据，需要保存为文件');
        // 构建图片保存路径和名称，正式环境应该保存到云存储
        // 此处省略具体实现...
      }
      
      // 图片路径可能需要转换为可访问的URL
      if (imageUrl && !imageUrl.startsWith('http')) {
        // 转换相对路径为绝对URL
        const serverBaseUrl = process.env.SERVER_URL || 'http://localhost:3000';
        imageUrl = `${serverBaseUrl}/uploads/images/${path.basename(imageUrl)}`;
        logger.info(`转换图片路径为公网可访问URL: ${imageUrl}`);
      }
      
      // 更新诊断记录中的图片URL
      diagnosisRecord.imageUrl = imageUrl;
      
      const recordId = await userService.saveDiagnosisRecord(pool, userId, diagnosisRecord);
      
      return res.json({
        success: true,
        data: { recordId }
      });
    } catch (err) {
      logger.error('保存诊断记录失败', {
        error: err.message,
        stack: err.stack
      });
      
      return res.status(500).json({
        success: false,
        message: '保存诊断记录失败',
        error: err.message
      });
    }
  });
  
  /**
   * 获取用户诊断历史
   */
  router.get('/diagnosis-history', async (req, res) => {
    const { userId, limit = 20, offset = 0 } = req.query;
    
    if (!userId) {
      return res.status(400).json({
        success: false,
        message: '缺少用户ID'
      });
    }
    
    try {
      const history = await userService.getUserDiagnosisHistory(
        pool, 
        parseInt(userId), 
        parseInt(limit), 
        parseInt(offset)
      );
      
      return res.json({
        success: true,
        data: history
      });
    } catch (err) {
      logger.error('获取诊断历史失败', {
        error: err.message,
        stack: err.stack
      });
      
      return res.status(500).json({
        success: false,
        message: '获取诊断历史失败',
        error: err.message
      });
    }
  });
  
  return router;
};
